#include "mapa.h"

void NewMap(Mapa *p_a)
{
    p_a->m_x=0;
    p_a->m_y=0;

    p_a->m_celulas =NULL;
}
void StartMap (Mapa *p_a, int p_x,int p_y)
{
    int i;
    p_a->m_x=p_x;
    p_a->m_y=p_y;
    p_a->m_estuturas=0;
    p_a->m_celulas = (Cells**)calloc(sizeof(Cells*),p_x);

    if (p_a->m_celulas == NULL)
    {
        printf( "Socorro! malloc devolveu NULL!\n");
        exit( EXIT_FAILURE);
    }
    for (i=0; i<p_x; i++)
    {
        p_a->m_celulas[i] = (Cells*)calloc(sizeof(Cells),p_y);

        if (p_a->m_celulas[i] == NULL)
        {
            printf( "Socorro! malloc devolveu NULL!\n");
            exit( EXIT_FAILURE);
        }
    }
}
void PrintMap(Mapa *p_a)
{
//    int i,j;
//    for (i = 0; i < p_a->m_x; i++)
//    {
//        for (j = 0; j < p_a->m_y; j++)
//            printf("%d ", p_a->m_celulas[i][j].valor);
//        printf("\n");
//    }
//    printf("Flags\n");
//    for (i = 0; i < p_a->m_x; i++)
//    {
//        for (j = 0; j < p_a->m_y; j++)
//            printf("%d ", p_a->m_celulas[i][j].flag);
//        printf("\n");
//    }
    int numeroDeCelulas=p_a->m_x*p_a->m_y;

    printf("Numero de celulas da imagem: %d \n", numeroDeCelulas);
    printf("Numero de construcoes: %d \n", p_a->m_estuturas);
}

void ReadMap(Mapa *p_a,FILE * p_input)
{
    int i,j;
    int v_valor;
    for(i=0; i < p_a->m_x; i++)
    {
        for(j=0; j < p_a->m_y; j++)
        {
            fscanf(p_input,"%d",&v_valor);
            //printf("%d",v_valor);

            p_a->m_celulas[i][j].valor = v_valor;
            p_a->m_celulas[i][j].flag = 0;
        }
    }
}



float **Alocar_matriz_real (int m, int n)
{
  float **v;  /* ponteiro para a matriz */
  int   i;    /* variavel auxiliar      */
  if (m < 1 || n < 1) { /* verifica parametros recebidos */
     printf ("** Erro: Parametro invalido **\n");
     return (NULL);
     }
  /* aloca as linhas da matriz */
  v = (float **) calloc (m, sizeof(float *));
  if (v == NULL) {
     printf ("** Erro: Memoria Insuficiente **");
     return (NULL);
     }
  /* aloca as colunas da matriz */
  for ( i = 0; i < m; i++ ) {
      v[i] = (float*) calloc (n, sizeof(float));
      if (v[i] == NULL) {
         printf ("** Erro: Memoria Insuficiente **");
         return (NULL);
         }
      }
  return (v); /* retorna o ponteiro para a matriz */
}


int FindStructures(Mapa *p_a)
{
    int i,j, v_estruturas;
    v_estruturas =0;


    for(i=0; i< p_a->m_x;i++)
    {
        for(j=0; j< p_a->m_y;j++)
        {
            if (p_a->m_celulas[i][j].valor==1&&p_a->m_celulas[i][j].flag==0)
            {
                roundSearch(p_a, i, j);
                v_estruturas ++;
            }
            //procura em volta
            p_a->m_celulas[i][j].flag=1;
        }
    }
    p_a->m_estuturas= v_estruturas;
    //p
    return 0;
}

void roundSearch(Mapa *p_a, int x, int y)
{
    if(x<0||y<0||x>=(p_a->m_x)||y>=(p_a->m_y))
        return;
    if(p_a->m_celulas[x][y].flag ==1)
        return;
    if(p_a->m_celulas[x][y].valor ==0)
        return;
    else
        p_a->m_celulas[x][y].flag =1;
    roundSearch(p_a,  x+1,  y);
    roundSearch(p_a,  x+1,  y+1);
    roundSearch(p_a,  x+1,  y-1);
    roundSearch(p_a,  x-1,  y);
    roundSearch(p_a,  x-1,  y+1);
    roundSearch(p_a,  x-1,  y-1);
    roundSearch(p_a,  x,  y+1);
    roundSearch(p_a,  x,  y-1);


}
